Hmm, is it a requirement for Signal.set to take a different datatype to its internal datatype? I know we do this for type coercion (take a string or a float, convert, store as float), but this example seems to promote this to requiring a different datatype. This will break typing...

I don't think I quite understand. How does it promote requiring something?

If CallableSignalBackend.put calls any callable then it must be typed Any or perhaps T. This requires that Signal.set also be typed Any or T.

Example:

sig = soft_signal_rw(float, setter=config_setter)
await sig.set(32.4)  # pyright says ok, runtime says ok
value = await sig.get_value()  # value is float
await sig.set(MotorConfig(...))  # pyright says bad, runtime says ok
value = await sig.get_value()  # value is float

I don't think I want to promote a pattern where the set argument type is different from the value type

@coretl What do you suggest then? If we say that the setter can only take one argument of the same type as the value carried by the function, then that strictly limits the types of operations we can reasonably support.

I have viewed a few third-party libraries for device control, not enough to constitute as an expert on the matter, but I haven't found so far the situation where an entire data structure is passed down to a function controlling a device. I've seen more use case of APIs with multiple parameters, but in that case using functools.partial to bind other arguments should be sufficient.

@burkeds have you encountered these situations before?

Good point, we probably need the concept of setpoint and reading:

• initial value goes to self._setpoint and self.reading
• put value goes through converter, then stored as self._setpoint
• setter called on self._setpoint, if it returns a value that goes in self.reading, otherwise call getter to get that value

A possible issue. Currently, the value is not converted until self.set_value(...).

If we put self._setpoint = self.converter.write_value(value) in set_value that works provided there is not setter. If there is a setter then the converted write value would not be accurate to assign as self._setpoint because the value is not converted before it is passed to the setter.

Should we pass the converted write value to the setter?

    def set_value(self, value: SignalDatatypeT):
        """Set the current value, alarm and timestamp."""
        self.reading = Reading(
            value=self.converter.write_value(value),
            timestamp=time.time(),
            alarm_severity=0,
        )
        if self.callback:
            self.callback(self.reading)

    async def put(self, value: Any) -> None:
        write_value = self.initial_value if value is None else value
        if self._setter is not None:
            written_value = await maybe_await(self._setter(value))
            if written_value is not None:
                self.set_value(written_value)
            elif self._getter is not None:
                await self._update_value_from_getter()
            else:
                self.set_value(write_value)
        else:
            self.set_value(write_value)

Should we pass the converted write value to the setter?

I think that's probably best

Because the setter is possibly async, it can't go in set_value. That means to pass the converted value to the setter we need to convert the value twice, once in put and once in set_value. I didn't want to do that.

Instead, I thought we could pass the unconverted value to the setter (as I am sure a user would expect) and the setpoint is then recorded as the value passed to set_value.

I'm not sure I agree, let's go with an example of a float signal with a setter:

• I call signal.set("34.56")
• First this converts the value to 34.56
• Then it calls setter(34.56)
• Imagine that setter returns 34.6

In this example I would suggest that the setpoint is 34.56 and the value is 34.6. Would you agree?

If so then this becomes:

    async def put(self, value: Any) -> None:
        self._setpoint = self.initial_value if value is None else self.converter.write_value(value)
        if self._setter is not None:
            readback = await maybe_await(self._setter(value))
            if readback is not None:
                self.set_value(readback)
            elif self._getter is not None:
                await self._update_value_from_getter()
            else:
                self.set_value(self._setpoint)
        else:
            self.set_value(self._setpoint)

Agree

Agree, as per #1280 (comment)

Disagree, #1280 (comment) would pass the converted value to the setter

agree